…rappers

Each per-key Signal allocates a wrapper object plus its own Dependency.
At 1000+ records × ~5 keys at mount, wrappers dominate the per-record
allocation count and visibly cost on bulk-add-500 / create-1k /
each-mount-1000. Replaces the per-key Signal Map with two stores: a
values Map (always allocated) and a deps Map (lazy, allocated on first
reactive read). Per-key Dependencies allocate only when something
actually subscribes — purely closure-captured records pay zero per-key
dep cost.

Equality dedup is preserved by snapshotting Signal.equalityFunction at
RDC construction. Mirrors Signal's own per-instance snapshot semantics:
late overrides of the static do not retroactively retarget already-
constructed instances. setKey writes parent[key] unconditionally
(matching the prior signal.set + writeToParent ordering) and only fires
the per-key Dependency when the equality check sees a real change.
keySetVersion still fires on first observation of a new key so readers
that fell through to parent rewire on next run.

writeToParent and registerItemContext semantics unchanged. Proxy traps
unchanged in shape; trapGet now reads from target.values + lazily
populates target.deps. Module-scoped HANDLER_RO / HANDLER_RW preserved.

3046 logical tests pass (1 flaky iframe CORS in node-types.test.js;
file passes solo).

…ject

Every record in a bench-todo / bench-krausest mount adds the same keys
in the same order, letting V8 establish a stable hidden-class chain
across the whole list. Plain-object property access inline-caches at
the call site once the shape is stable; Map.get always pays a virtual
call. trapGet's hot path is now a single (prop in values) check + one
property read instead of two Map ops.

Existence checks use (prop in target.values) — fast on null-prototype
since there is no prototype chain to walk. dispose() reassigns
this.values = Object.create(null) so the hidden-class chain stays
clean across record reuse.

3631 logical tests pass (1 flaky iframe CORS, file passes solo).

…ision

Adds explicit failing tests for the per-key isolation contracts FGR was
designed to deliver. Currently 9 of these fail — they pin the contract
so subsequent code work has clear targets and so a future regression
can't quietly creep back in.

Restored:
- Test 25 in subtree-caching ("closure-captured data in subtemplate")
  captures the data.todo.completed-via-setProperty contract that the
  CodePlayground regression demonstrated is real, not a fallacy. Removed
  in 942f887 on flawed reasoning that "data is snapshot"; the
  CodePlayground bug confirms the contract is needed.

New in subtree-spurious "FGR per-key isolation contract":
- each-block in-place mutation per-field isolation
- each-block cross-item isolation (sibling items don't re-fire)
- subtemplate reactiveData shorthand syntax per-key isolation
- subtemplate-inside-each composition (bench-todo case) per-key
  isolation across the each → subtemplate boundary

Existing kept:
- it.fails 'reactiveData per-key' verbose syntax (line 525)
- snippet args per-key isolation (passes — lazy-getter path)
- blob data coarse fanout (passes — negative control)
- per-key isolation across N subtemplates at scale (the bench scenario)

Currently failing tests document the gap between FGR design and
delivery. Diagnosis from runtime trace: subtemplate bindings register
on the renderer's coarse `dataDep` via `lookupExpression`, and
`bumpDataVersion` fires on every parent update via the
setDataContext → render() path. The per-key Deps in `ReactiveDataContext`
are correctly populated by `setupReactiveSubtemplate`, but coarse fanout
defeats their isolation downstream.

`getEachData` for as-mode returns a fixed shape — `{ [as], [indexAs] }`.
The value-key set never gains a key after the seed `replace()` call.
Subscribing to `keySetVersion` on every parent-context fallthrough read
(helpers, parent state, anything not in the value-key set) was pure
waste — the Dep can never fire under as-mode.

The seal: `sealKeysAfterReplace: true` opt-in flips a `keysSealed` flag
at the end of `replace()`. trapGet skips `keySetVersion.depend()` when
sealed; setKey skips `keySetVersion.changed()` when sealed.

`active-indicator-200` was paying ~60,000 wasted Set ops per cycle from
keySetVersion subscribe/cleanup churn (200 records × 100 cycles × 3 Set
ops per round-trip on a Dep with no possible firing path). Closes
roughly half the regression vs main.

Spread-mode keeps the unsealed default — spread item shapes can gain
keys, and the as-mode-per-field-isolation followup plan relies on
spread's per-field reactivity staying intact.

The companion `eager Map+Dep allocation at setKey` change measured
mixed: helped active-indicator-200 incrementally, hurt each-mount-1000
and remove-last-100 by adding ~1 Dep allocation per record × 1000
records. Sequenced separately; eager allocation parked until a
narrower targeting strategy emerges.

…templates"

This reverts commit 0161749.